package elastic.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.alibaba.fastjson.JSON;
import com.css.sword.knowing.search.comm.SearchConst;



/**
 * @author 作者 E-mail:caihx@css.com.cn
 * @date 创建时间：2018年08月29日 上午11:54:48
 * @version 1.0
 */
@SuppressWarnings("unchecked")
public class SearchQueryMap {

    /**
     * 判断对象是否为空或null
     * 
     * @param obj 对象
     * @return true：空，false：非空
     */
    public static boolean isEmpty(Object obj)
    {
        if(obj == null)
        {
            return true;
        }
        if(obj instanceof List)
        {
            return ((List)obj).size() == 0;
        }
        if(obj instanceof String)
        {
            return ((String)obj).trim().equals("");
        }
        if (obj instanceof Map) {
            return ((Map)obj).isEmpty();
        }
        return false;
    }

    /**
     * Map转成json
     * 
     * @param map 拼装好的map
     * @return json字串
     */
    public static String getJSONString(Map map)
    {
        if(map != null)
        {
            return JSON.toJSONString(map);
        }
        return null;
    }
    
    /**
     * 获取普通字段的map
     * 
     * @param value     条件值
     * @param operator  搜索项间关系，默认传入null
     * @param method    检索方式，默认传入null
     * @return          返回Map
     */
    public static Map createFieldMap(Object value, String operator, String method)
    {
        if(!isEmpty(value))
        {
            final Map<String, Object> val = new HashMap<String, Object>();
            val.put("val", value);
            if(!StringUtils.isEmpty(operator))
            {
                val.put("operator", operator);
            }
            
            if(!StringUtils.isEmpty(method))
            {
                val.put("method", method);
            }
            
            return val;
        }
        return null;
    }
    
    /**
     * 获取范围条件的map
     * 
     * @param op1       范围操作1
     * @param value1    范围字段值1
     * @param op2       范围操作2
     * @param value2    范围字段值2
     * @param operator  搜索项间关系
     * @return           返回Map
     */
    public static Map createRangeFieldMap(String op1, Object value1, String op2, Object value2, String operator)
    {
        final Map<String, Object> val = new HashMap<String, Object>();
        boolean flag = false;
        
        if(!StringUtils.isEmpty(op1) && !isEmpty(value1))
        {
            final Map<String, Object> m = new HashMap<String, Object>();
            m.put(op1, value1);
            val.put("val", m);
            flag = true;
        }
        
        if(!StringUtils.isEmpty(op2) && !isEmpty(value2))
        {
            final Map<String, Object> m = new HashMap<String, Object>();
            m.put(op2, value2);
            val.put("val2", m);
            flag = true;
        }
        
        if(flag)
        {
            if(!StringUtils.isEmpty(operator))
            {
                val.put("operator", operator);
            }
            
            val.put("method", SearchConst.SEARCH_METHOD_RANGE);
            
            return val;
        }
        
        return null;
    }

    /**
     * 获取嵌套map
     * 
     * @param map 字段的Map集合
     * @return    嵌套类型的Map
     */
    public static Map createNestedFieldMap(Map map)
    {
        final Map<String, Object> val = new HashMap<String, Object>();
    
        if(null!=map)
        {
            val.put("nested", map);
            return val;
        }    
        return null;
    }
    
    /**
     * 设置普通字段的条件Map
     * 
     * @param where     检索条件Map
     * @param fname     字段名称
     * @param value     条件值
     * @param operator  搜索项间关系，默认传入null
     * @param method    检索方式，默认传入null
     * @return          返回条件Map
     */
    public static Map setFieldMap(Map where, String fname, Object value, String operator, String method)
    {
        if(!StringUtils.isEmpty(fname))
        {
            final Map m = createFieldMap(value, operator, method);
            if(m != null)
            {
                where.put(fname, m);
            }
        }
        
        return where;
    }
    
    /**
     * 设置子条件的搜索项间关系
     * 
     * @param where     检索条件Map
     * @param operator  搜索项间关系
     * @param obj       子条件
     * @return          返回条件Map
     */
    public static Map setOperatorMap(Map where, String operator, Object obj)
    {
        if (!isEmpty(obj)) {
            if (!StringUtils.isEmpty(operator)) {
                where.put(operator, obj);
            } else {
                where.put(SearchConst.SEARCH_OPERATOR_MUST, obj);
            }
        }
        return where;
    }

    /**
     * 设置范围条件的Map
     * 
     * @param where     检索条件Map
     * @param fname     字段名称
     * @param op1       范围操作1
     * @param value1    范围字段值1
     * @param op2       范围操作2
     * @param value2    范围字段值2
     * @param operator  搜索项间关系
     * @return          返回条件Map
     */
    public static Map setRangeFieldMap(Map where, String fname, String op1, Object value1, String op2, Object value2, String operator)
    {
        if(!StringUtils.isEmpty(fname))
        {
            final Map m = createRangeFieldMap(op1, value1, op2, value2, operator);
            if(m != null)
            {
                where.put(fname, m);
            }
        }
        
        return where;
    }

    /**
     * 设置检索条件Map
     * 
     * @param where  检索条件Map
     * @param path   路径名称
     * @param map    字段的Map集合
     * @return       条件Map
     */
    public static Map setNestedFieldMap(Map where, String path, Map map)
    {
        if(!StringUtils.isEmpty(path))
        {
            final Map m = createNestedFieldMap(map);
            if(m != null)
            {
                where.put(path, m);
            }
        }
        
        return where;
    }
}

